const regeneratorRuntime = require('./lib/regeneratorRuntime');
import {Config} from 'config.js';

class Base{


    /**
     * post静态请求函数
     * http 请求类, 当noRefech为true时，不做未授权重试机制
     */
    static request(params) {
        var params = this.paramsValidate(params);
        wx.request({
            url: params.url,
            method: params.type,
            data: params.data,
            header: params.header,
            success: (res) => {
                wx.hideLoading();
                params.success && params.success(res.data);
            }, fail: (err) => {
                this._processError(err);
                wx.hideLoading();
                params.error && params.error(err);
            }
        });
    }

    /**
     * Promise async await 静态请求函数
     * http 请求类, 当noRefech为true时，不做未授权重试机制
     */
    static http_request(params) {
        var params = this.paramsValidate(params);
        return new Promise((resolve, reject) => {
            wx.request({
                url: params.url,
                method: params.type,
                data: params.data,
                header: params.header,
                success: (res) => {
                    wx.hideLoading();
                    resolve(res.data) //成功调用resolve
                },fail: (err) => {
                    wx.hideLoading();
                    this._processError(err);
                    reject(err) //失败调用reject
                }
            });
        });
    }

    //参数验证
    static paramsValidate(params) {
        if (params == undefined) {
            wx.showToast({
                title: '缺少参数',
                icon: 'none',
                duration: 3000
            })
            return false;
        }
        if ((typeof params) != 'object') {
            wx.showToast({
                title: '参数必须是一个对象',
                icon: 'none',
                duration: 3000
            })
            return false;
        }
        if (params.url == undefined) {
            wx.showToast({
                title: '缺少参数url',
                icon: 'none',
                duration: 3000
            })
            return false;
        }

        if (params.type == undefined) {
            params.type = 'get';
        }

        if (params.data == undefined) {
            params.data = {};
        }

        if (params.header == undefined) {

        }

        //从本地缓存中获取token
        params.header = {
            'content-type': 'application/json'
        };
        if(Config.headerTokenState){
            params.header.token= wx.getStorageSync(Config._storageTokenName);
        }

        return params;
    }

    static _processError(err) {
        console.log(err);
    }

    /*
     *获得元素上的绑定的值
    */
    static getDataSet(event, key) {
        if(key){
            return event.currentTarget.dataset[key];
        }else{
            return event.currentTarget.dataset;
        }
    };

    /**
    * json对象转url参数
    * @param data 对象
    */
    static parseParams(data) {
        var _result = [];
        for (var key in data) {
            var value = data[key];
            if(value!=null && value!=""){
                if (value.constructor == Array) {
                    value.forEach(function (_value) {
                        _result.push(key + "=" + _value);
                    });
                } else {
                    _result.push(key + '=' + value);
                }
            }else{
                _result.push(key + '=' + value);
            }
        }
        return '?' + _result.join('&');
    }

    /**
     * 获取小程序扫码传过来的参数
     * obj 对象（scene:要分割的字符串，separator:字符串或正则表达式，从该参数指定的地方分割,默认是逗号)
     * 例：{scene: "43%2C83%2C75%2C1%2Cfalse", separator: ","}
     */
    static getScanParams(obj) {
        if(obj.scene == undefined){
            return false;
        }
        const scene = decodeURIComponent(obj.scene);
        if (obj.separator == undefined) {
            obj.separator = ','
        }
        let params = scene.split(obj.separator);
        return params;
    }

    /*======================== start 获取上一页中的传值,返回上一页并传值 ==========================*/
    /**
     *设置当前页值并传给上一页传值
     * @obj 对象
     */
    static setCurrentPageValue(obj) {
        if (!obj) {
            throw '参数不能为空';
        }
        if ((typeof obj) != 'object') {
            throw '不是对象';
        }
        var pages = getCurrentPages();
        var prevPage = pages[pages.length - 2]; //上一个页面
        //直接调用上一个页面的setData()方法，把数据存到上一个页面中去
        prevPage.setData(obj)
    }
    /**
     * 获取上一页中的传值
     * *将想要传的信息赋值给上一个页面data中的值
     */
    static getPreviousPageValue(){
        var pages = getCurrentPages();//获取所有页面
        var currPage = pages[pages.length - 1]; //获取当前页面，将其赋值
        let params = currPage.data;//这是拿到了上一页js中data里面的数据
        return params
    }
    /**
     *返回上一页并传值
     * @obj 对象
     */
    static backPreviousPageValue(obj){
        if(!obj){
            throw '参数不能为空';
        }
        if((typeof obj)!='object'){
            throw '不是对象';
        }
        var pages = getCurrentPages();
        var prevPage = pages[pages.length - 2]; //上一个页面
        //直接调用上一个页面的setData()方法，把数据存到上一个页面中去
        prevPage.setData(obj)
        //返回
        wx.navigateBack({delta: 1})
    }

    /*======================== end 获取上一页中的传值,返回上一页并传值 ==========================*/


    /**
     * 设置头部标题
     */
    static navTitle(str) {
        wx.setNavigationBarTitle({ title: str });
    }

    /**
     * Toast提示
     */
    static toast(params) {
        var obj = { title: params, icon: 'none', duration: 3000 }
        if ((typeof obj) == 'object') {
            if (params.title != undefined) {
                obj.title = params.title;
            }
            if (params.icon != undefined) {
                obj.icon = params.icon;
            }
            if (params.duration != undefined) {
                obj.duration = params.duration;
            }
        } else {
            //字符串
            obj.title = params;
        }
        wx.showToast(obj)
    }

    /*======================== start 本地缓存 ==========================*/
    /**
     * 获取本地缓存数据
     */
    static getLocalCache(key) {
        if(key){
            var res = wx.getStorageSync(key);
        }else{
            var res = wx.getStorageSync(Config._storageKeyName);
        }
        if (!res) {
            res = [];
        }
        return res;
    }

    /**
     * 本地缓存 保存／更新
     * 如果第二个参数存在，第一个参数是key,第二个参数是data
     */
    static execSetStorageSync(data,key) {
        if(key){
            wx.setStorageSync(data, key);
        }else{
            wx.setStorageSync(Config._storageKeyName, data);
        }
    };

    /**
     * 清空本地缓存
     */
    static emptyLocalCache(key) {
        if(key){
            wx.removeStorageSync(key)
        }else{
            wx.removeStorageSync(Config._storageKeyName)
        }
    };
    /*======================== end 本地缓存 ==========================*/

    /**
     * 时间戳转换日期
     * @param {*} number 时间戳
     * @param {*} format 日期格式,例：'Y-M-D'
     */
    static formatTimeTwo(number, format) {
        var formateArr = ['Y', 'M', 'D', 'h', 'm', 's'];
        var returnArr = [];

        var date = new Date(number);
        returnArr.push(date.getFullYear());
        returnArr.push(this.formatNumber(date.getMonth() + 1));
        returnArr.push(this.formatNumber(date.getDate()));
        returnArr.push(this.formatNumber(date.getHours()));
        returnArr.push(this.formatNumber(date.getMinutes()));
        returnArr.push(this.formatNumber(date.getSeconds()));

        for (var i in returnArr) {
            format = format.replace(formateArr[i], returnArr[i]);
        }
        return format;
    }
    static formatNumber(n) {
        n = n.toString()
        return n[1] ? n : '0' + n;
    }

    /**
    * 获取身份证中的信息
    * idCard 身份证号
    * num:1出生日期,2性别,3年龄
    */
    static getIdCardInfo(idCard,num) {
        if (num == 1) {
            //获取出生日期
            var birth = idCard.substring(6, 10) + "-" + idCard.substring(10, 12) + "-" + idCard.substring(12, 14);
            return birth;
        }
        if (num == 2) {
            //获取性别
            if (parseInt(idCard.substr(16, 1)) % 2 == 1) {
                return "男";
            } else {
                return "女";
            }
        }
        if (num == 3) {
            //获取年龄
            var myDate = new Date();
            var month = myDate.getMonth() + 1;
            var day = myDate.getDate();
            var age = myDate.getFullYear() - idCard.substring(6, 10) - 1;
            if (idCard.substring(10, 12) < month || idCard.substring(10, 12) == month && idCard.substring(12, 14) <= day) {
                age++;
            }
            return age;
        }
    }

    //获取当前日期
    static getCurrentDate(flag) {
        var now = new Date();
        var year = now.getFullYear(); //得到年份
        var month = now.getMonth();//得到月份
        var date = now.getDate();//得到日期
        var day = now.getDay();//得到周几
        var hour = now.getHours();//得到小时
        var minu = now.getMinutes();//得到分钟
        var sec = now.getSeconds();//得到秒
        var week;
        month = month + 1;
        if (month < 10) month = "0" + month;
        if (date < 10) date = "0" + date;
        if (hour < 10) hour = "0" + hour;
        if (minu < 10) minu = "0" + minu;
        if (sec < 10) sec = "0" + sec;
        
        var time = "";
        // var arr_week = new Array("星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六");
        // week = arr_week[day];
        // time = year + "年" + month + "月" + date + "日" + " " + hour + ":" + minu + ":" + sec + " " + week;
        switch (flag) {
            case 'year':
                time=year;
                break;
            case 'month':
                time=month;
                break;
            case 'date':
                time=date;
                break;
            case 'ymd':
                time=year + "-" +month + "-" +date;
                break;
            case 'hms':
                time=hour + ":" + minu + ":" + sec;
                break;
            case 'ymdhms':
                time=year + "-" +month + "-" +date+ " " +hour + ":" + minu + ":" + sec;
                break;
        
            default:
                break;
        }
        return time;
    }

    //wx.login封装城同步
    static wx_login(){
        return new Promise(function(reslove,reject){
            wx.login({
                success (res) {
                    reslove(res.code);
                },fail: function (err) {
                    reject(err) //失败调用reject
                }
            })
        })
    }
    //异步获取openid
    static getOpenidAsync(url) {
        wx.login({
            success: (res) => {
                base.request({
                    url: url,
                    data: { code: res.code },
                    success: (result) => {
                        wx.setStorageSync(this._storageOpenid, result.data);
                    }
                });
            }, fail: function (err) {
                console.log('wx.login 接口调用失败，将无法正常使用开放接口等服务', err);
            }
        });
    }

    //同步获取openid
    static async getOpenidAync(url) {
        var code=await this.wx_login();
        var result=await this.http_request({
            url: url,
            data:{code:code}
        });
        wx.setStorageSync(this._storageOpenid, result.data);
        return result.data.openid
    }
    //字符串截取
    static strSub(str,len){
        if(str==undefined || str==null || str==""){
            return '';
        }
        if(!len){
            throw '缺少参数len';
        }
        return str.substring(0,len);
    }

    //判断变量是否为空
    static isEmpty(value){
        if(value==null || value==""){
            return true;//空
        }
        return false;
    }

    //判断变量是否存在
    static isset(value){
        if(value==undefined){
            return false;  
        }
        return true;//存在
    }

    //判断变量是不是字符串
    static isString(value){
        if((typeof value)=="string"){
            return true;//是
        }
        return false;
    }
    //判断对象是否为空
    static isObjEmpty(obj){
        if(JSON.stringify(obj)=="{}"){
            return true;//空
        }
        return false;
    }
    //判断变量是否为对象
    static isObject(value){
        if(value instanceof Object){
            return true;//是
        }
        return false;
    }

    //判断变量是否为数组
    static isArray(value){
        if(value instanceof Array){
            return true;//是
        }
        return false;
    }

    /**
     * 字符串固定位置插入字符
     * @param {*} soure 字符串变量
     * @param {*} start 插入位置
     * @param {*} newStr 要插入的字符
     */
    static insertStr(soure, start, newStr){   
        return soure.slice(0, start) + newStr + soure.slice(start);
    }

    //每天执行一次(最新的，不用设置开始时间)
    static dailyExecution(callback,flag='regular_implementation'){
        var info=wx.getStorageSync(flag);
        //不存在设置上
        if(!info){
            wx.setStorageSync(flag, new Date().toLocaleDateString());
            callback();
        }else{
            //保存要本地的时间不同就不执行回调，代码
            if (new Date().toLocaleDateString() != wx.getStorageSync(flag)) {
                wx.removeStorageSync(flag);
                wx.setStorageSync(flag, new Date().toLocaleDateString());
                callback();
            }
        }
    }

    //播放音乐
    static playMusic(src){
        const innerAudioContext = wx.createInnerAudioContext()
		innerAudioContext.autoplay = true
		// innerAudioContext.src = 'http://www.baidu.com/hb.mp3'
		innerAudioContext.src =src;
		innerAudioContext.onPlay(() => {
			console.log('开始播放')
		})
		innerAudioContext.onError((res) => {
			console.log(res.errMsg)
			console.log(res.errCode)
		})
    }
    //替换字符串中的html元素
    static replaceHtmlElements(str){
        return str.replace(/(<br>|<br\/>|↵)/g,'\n');
    }
    /**
     * 获取用户的当前设置
     * wx.getSetting封装城同步
     */
    static wx_getSetting() {
        return new Promise(function (reslove, reject) {
            wx.getSetting({
				success: function (res) {
                    reslove(res);
				},fail:function(err){
                    reject(err) //失败调用reject
                }
			});
        })
    }
    /**
     * 打开设置页面进行授权设置
     * wx.openSetting封装城同步
     */
    static wx_openSetting() {
        return new Promise(function (reslove, reject) {
            wx.openSetting({
                success: function (res) {
                    reslove(res);
                },fail:function(err){
                    reject(err) //失败调用reject
                }
            });
        })
    }

    //获取当前开发环境
    static getEnvVersion(){
        var obj={name:'develop',desc:'开发版'};

        if(__wxConfig.envVersion=='release') {

            obj={name:'release',desc:'正式版'};
            
        }else if(__wxConfig.envVersion=='trial'){

            obj={name:'trial',desc:'体验版'};
            
        }
        return obj;
    }

};

export { Base };
